const fs = require('fs');
const path = require('path');

// 导入JSON配置管理器
const JsonConfigManager = require('./lib/config/json-config-manager');
const ConfigPathResolver = require('./lib/config/config-path-resolver');

// 导入API适配器
const MoonshotAdapter = require('./lib/api/moonshot-adapter');

// 导入日志管理器
const { createLogger } = require('./logger');
const logger = createLogger('analyze');

// 导入优化工具
const AdvancedImageOptimizer = require('./lib/utils/advanced-image-optimizer');
const TimeoutManager = require('./lib/utils/timeout-manager');
const ImageOptimizationConfig = require('./lib/config/image-optimization-config');

// 初始化优化工具
const advancedImageOptimizer = new AdvancedImageOptimizer();
const timeoutManager = new TimeoutManager();
const imageOptimizationConfig = new ImageOptimizationConfig();

// 确定项目根目录，支持从不同目录调用
const projectRoot = path.resolve(__dirname, '.');

// 初始化配置系统
const pathResolver = new ConfigPathResolver();
const configManager = new JsonConfigManager(projectRoot);

// 加载配置（使用标准跨平台路径）
let configPathInfo = null;
try {
    configPathInfo = pathResolver.getBestConfigPath(projectRoot);
    if (configPathInfo) {
        console.log(`[Vision Analyzer] 加载配置文件: ${configPathInfo.path} (来源: ${configPathInfo.source})`);
        configManager.configPath = configPathInfo.path;
        configManager.loadConfig();
    } else {
        console.warn('[Vision Analyzer] 警告: 未找到配置文件，使用默认配置');
        pathResolver.ensureConfigDir();
        configManager.configPath = pathResolver.getConfigFilePath();

        // 检查是否已有生产配置文件存在，避免覆盖真实配置
        const productionConfigPath = pathResolver.getConfigFilePath();
        if (!fs.existsSync(productionConfigPath)) {
            // 只在配置文件不存在时才创建默认配置
            const isTestEnvironment = process.env.NODE_ENV === 'test' ||
                                    process.env.JEST_WORKER_ID !== undefined ||
                                    process.env.npm_config_argv?.includes('test');
            configManager.createDefaultConfig(isTestEnvironment);
        } else {
            console.log('[Vision Analyzer] 发现现有配置文件，跳过默认配置创建');
        }
    }
} catch (error) {
    console.error('[Vision Analyzer] 配置加载失败:', error.message);
    // 创建默认配置作为fallback，但先检查是否已有配置文件
    pathResolver.ensureConfigDir();
    configManager.configPath = pathResolver.getConfigFilePath();

    // 检查是否已有配置文件存在，避免覆盖真实配置
    const existingConfigPath = pathResolver.getConfigFilePath();
    if (!fs.existsSync(existingConfigPath)) {
        // 只在配置文件不存在时才创建默认配置
        const isTestEnvironment = process.env.NODE_ENV === 'test' ||
                                process.env.JEST_WORKER_ID !== undefined ||
                                process.env.npm_config_argv?.includes('test');
        configManager.createDefaultConfig(isTestEnvironment);
    } else {
        console.log('[Vision Analyzer] 发现现有配置文件，跳过默认配置创建');
    }
}

// 导入PromptManager来管理提示词
const PromptManager = require('./prompt-manager');
const promptManager = new PromptManager(projectRoot);

/**
 * 错误日志记录功能
 */
class ErrorLogger {
    constructor() {
        this.logDir = path.join(projectRoot, 'tmp');
        this.logFile = path.join(this.logDir, 'vision-analyzer-errors.log');
        this.ensureLogDir();
    }

    ensureLogDir() {
        try {
            if (!fs.existsSync(this.logDir)) {
                fs.mkdirSync(this.logDir, { recursive: true });
            }
        } catch (error) {
            console.error('无法创建日志目录:', error.message);
        }
    }

    logError(functionName, error, context = {}) {
        const timestamp = new Date().toISOString();
        const logEntry = {
            timestamp,
            function: functionName,
            error: {
                message: error.message,
                stack: error.stack,
                name: error.name
            },
            context
        };

        const logMessage = `[${timestamp}] ${functionName}: ${error.message}\n` +
                          `Context: ${JSON.stringify(context, null, 2)}\n` +
                          `Stack: ${error.stack}\n` +
                          '---\n';

        try {
            fs.appendFileSync(this.logFile, logMessage, 'utf8');
            console.error(`错误已记录到: ${this.logFile}`);
        } catch (writeError) {
            console.error('无法写入错误日志:', writeError.message);
        }
    }

    logApiError(functionName, provider, model, apiError, imageData = null) {
        this.logError(functionName, apiError, {
            type: 'API_ERROR',
            provider,
            model,
            apiResponse: apiError.message,
            imageDataLength: imageData ? imageData.length : 0,
            timestamp: new Date().toISOString()
        });
    }
}

const errorLogger = new ErrorLogger();

/**
 * 通用API请求函数，减少重复代码
 * @param {string} url - API端点URL
 * @param {Object} payload - 请求载荷
 * @param {string} apiKey - API密钥
 * @param {string} providerInfo - 提供商信息（用于日志）
 * @param {string} modelInfo - 模型信息（用于日志）
 * @param {number} timeout - 超时时间（毫秒）
 * @returns {Promise<Object>} - API响应结果
 */
async function makeApiRequest(url, payload, apiKey, providerInfo, modelInfo, timeout = 60000) {
    const controller = new AbortController();
    const timeoutId = setTimeout(() => {
        controller.abort();
    }, timeout);

    try {
        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${apiKey}`
            },
            body: JSON.stringify(payload),
            signal: controller.signal
        });

        clearTimeout(timeoutId);

        if (!response.ok) {
            const errorText = await response.text();
            throw new Error(`API调用失败 [Provider: ${providerInfo}, Model: ${modelInfo}] (${response.status}): ${errorText}`);
        }

        const result = await response.json();

        // 记录token使用情况（如果有）
        if (result.usage) {
            const inputTokens = result.usage.prompt_tokens || 0;
            const outputTokens = result.usage.completion_tokens || 0;
            const totalTokens = result.usage.total_tokens || 0;
            logger.debug(`Token消耗 [Model: ${modelInfo}]: 输入=${inputTokens}, 输出=${outputTokens}, 总计=${totalTokens}`);
        }

        return result;
    } catch (error) {
        clearTimeout(timeoutId);

        if (error.name === 'AbortError') {
            throw new Error(`API请求超时 [Provider: ${providerInfo}, Model: ${modelInfo}] (${timeout/1000}秒)：请求超时，请检查网络连接或稍后重试`);
        }

        throw error;
    }
}

/**
 * 处理图片输入，统一转换为 data URL 格式
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {string} - data URL 格式的图片数据
 */
function processImageInput(imgString) {
    if (fs.existsSync(imgString)) {
        const imageBuffer = fs.readFileSync(imgString);
        return `data:image/${path.extname(imgString).slice(1)};base64,${imageBuffer.toString('base64')}`;
    } else if (imgString.startsWith('data:image/')) {
        return imgString;
    } else {
        // 假设是base64字符串，添加data URL前缀
        return `data:image/png;base64,${imgString}`;
    }
}

/**
 * 通用的双图片对比基础函数
 * @param {string} imgString1 - 第一张图片的base64编码字符串或文件路径
 * @param {string} imgString2 - 第二张图片的base64编码字符串或文件路径
 * @param {string} prompt - 分析提示语
 * @param {string} defaultPromptKey - 默认提示语的键名
 * @param {string} errorPrefix - 错误消息前缀
 * @returns {Promise<string>} - 分析结果
 */
async function compareImagesBase(imgString1, imgString2, prompt, defaultPromptKey, errorPrefix) {
    let imageData1 = null;
    let imageData2 = null;
    let providerInfo = 'unknown';
    let modelInfo = 'unknown';

    try {
        // 验证current_provider_model配置
        const validation = validateCurrentProviderModel();
        if (!validation.valid) {
            throw new Error(`配置验证失败: ${validation.error}`);
        }

        const currentProvider = validation.provider;
        const currentModel = validation.model;

        // 根据提供商获取相应的配置
        const providerConfig = getProviderConfig(currentProvider);

        // 处理图片输入
        imageData1 = processImageInput(imgString1);
        imageData2 = processImageInput(imgString2);

        providerInfo = providerConfig.base.replace(/\/[^\/]*$/, '/***');
        modelInfo = currentModel;

        // 使用提供的prompt或默认prompt
        const finalPrompt = prompt || promptManager.getPrompt(defaultPromptKey);
        if (!finalPrompt) {
            throw new Error(`未找到${defaultPromptKey}提示词配置`);
        }

      // 构建请求体，同时包含两张图片
        const requestBody = {
            model: currentModel,
            messages: [
                {
                    role: "user",
                    content: [
                        {
                            type: "text",
                            text: finalPrompt
                        },
                        {
                            type: "image_url",
                            image_url: {
                                url: imageData1
                            }
                        },
                        {
                            type: "image_url",
                            image_url: {
                                url: imageData2
                            }
                        }
                    ]
                }
            ],
            max_tokens: 4096
        };

        // 设置超时控制器
        const controller = new AbortController();
        const timeoutId = setTimeout(() => {
            controller.abort();
        }, 120000); // 2分钟超时

        try {
            const response = await fetch(`${providerConfig.base}/chat/completions`, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/json',
                    'Authorization': `Bearer ${providerConfig.api_key}`
                },
                body: JSON.stringify(finalRequestBody),
                signal: controller.signal
            });

            clearTimeout(timeoutId);

            if (!response.ok) {
                const errorText = await response.text();
                throw new Error(`API调用失败 [Provider: ${providerConfig.base.replace(/\/[^\/]*$/, '/***')}, Model: ${currentModel}] (${response.status}): ${errorText}`);
            }

            const result = await response.json();

            if (result.choices && result.choices.length > 0) {
                // 提取token使用情况
                const usage = result.usage;
                if (usage) {
                    const inputTokens = usage.prompt_tokens || 0;
                    const outputTokens = usage.completion_tokens || 0;
                    const totalTokens = usage.total_tokens || 0;
                    logger.debug(`Token消耗 [Model: ${currentModel}]: 输入=${inputTokens}, 输出=${outputTokens}, 总计=${totalTokens}`);
                } else {
                    logger.debug(`API未返回token使用信息 [Model: ${currentModel}]`);
                }

                return result.choices[0].message.content;
            } else {
                throw new Error(`API返回格式异常 [Provider: ${providerConfig.base.replace(/\/[^\/]*$/, '/***')}, Model: ${currentModel}]，未找到分析结果`);
            }
        } catch (error) {
            clearTimeout(timeoutId);

            if (error.name === 'AbortError') {
                throw new Error(`API请求超时 [Provider: ${providerConfig.base.replace(/\/[^\/]*$/, '/***')}, Model: ${currentModel}] (120秒)：请求超时，请检查网络连接或稍后重试`);
            } else {
                throw error;
            }
        }

    } catch (error) {
        // 记录详细的错误日志
        errorLogger.logError(defaultPromptKey, error, {
            imgString1Length: imgString1 ? imgString1.length : 0,
            imgString2Length: imgString2 ? imgString2.length : 0,
            imageData1Length: imageData1 ? imageData1.length : 0,
            imageData2Length: imageData2 ? imageData2.length : 0,
            provider: providerInfo,
            model: modelInfo
        });

        return `${errorPrefix}: ${error.message}`;
    }
}

/**
 * 分析图片内容
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @param {string} prompt - 分析提示语
 * @returns {Promise<string>} - 分析结果
 */
async function analyze_image(imgString, prompt) {
    let imageData = null;
    let providerInfo = 'unknown';
    let modelInfo = 'unknown';

    try {
        // 验证current_provider_model配置
        const validation = validateCurrentProviderModel();
        if (!validation.valid) {
            throw new Error(`配置验证失败: ${validation.error}`);
        }

        const currentProvider = validation.provider;
        const currentModel = validation.model;

        // 根据提供商获取相应的配置
        const providerConfig = getProviderConfig(currentProvider);

        // 统一使用 processImageInput 处理图片输入
        imageData = imgString;
        if (imgString && typeof imgString === 'string') {
            if (fs.existsSync(imgString)) {
                // 如果是文件路径，转换为完整 data URL
                imageData = processImageInput(imgString);
            } else if (!imgString.startsWith('data:image/')) {
                // 如果是纯 base64 字符串，转换为 data URL
                imageData = `data:image/png;base64,${imgString}`;
            }
        } else {
            throw new Error('图片参数无效：需要提供字符串格式的图片数据或文件路径');
        }

        // 优化图片数据以减少传输量
        try {
            // 获取原始图片信息用于智能配置
            const originalImageInfo = await advancedImageOptimizer.parseImage(imageData);

            // 确定任务类型（这里可以根据函数名或提示词内容判断）
            let taskType = 'default';
            if (prompt && typeof prompt === 'string') {
                if (prompt.includes('HTML') || prompt.includes('html')) {
                    taskType = 'generate_html_from_prototype';
                } else if (prompt.includes('设计') || prompt.includes('UI')) {
                    taskType = 'analyze_design_screenshot';
                } else if (prompt.includes('对比') || prompt.includes('比较')) {
                    taskType = 'compare_image';
                } else if (prompt.includes('组件') || prompt.includes('结构')) {
                    taskType = 'extract_component_hierarchy';
                }
            }

            // 使用智能配置选择最佳优化参数
            const optimizationConfig = imageOptimizationConfig.getAutoConfig(originalImageInfo, taskType);

            if (!optimizationConfig.enabled) {
                logger.debug('图片优化已禁用，使用原始数据');
                return;
            }

            logger.debug(`使用优化配置: ${imageOptimizationConfig.getConfigSummary(optimizationConfig)}`);

            const optimizationResult = await advancedImageOptimizer.optimizeImage(imageData, optimizationConfig);

            if (optimizationResult.optimizedInfo.optimized) {
                logger.info(`图片优化成功 [${taskType}]: ${optimizationResult.originalInfo.sizeMB}MB -> ${optimizationResult.optimizedInfo.sizeMB}MB ` +
                          `(${((1 - optimizationResult.optimizedInfo.size / optimizationResult.originalInfo.size) * 100).toFixed(1)}% 压缩率) ` +
                          `格式: ${optimizationResult.originalInfo.format} -> ${optimizationResult.optimizedInfo.format} ` +
                          `尺寸: ${optimizationResult.originalInfo.width}x${optimizationResult.originalInfo.height} -> ${optimizationResult.optimizedInfo.width}x${optimizationResult.optimizedInfo.height}`);

                imageData = optimizationResult.data;

                // 更新超时计算，使用优化后的图片大小
                const optimizedImageInfo = optimizationResult.optimizedInfo;
                if (this.optimizationCallback) {
                    this.optimizationCallback({
                        originalSize: optimizationResult.originalInfo.size,
                        optimizedSize: optimizationResult.optimizedInfo.size,
                        compressionRatio: ((1 - optimizationResult.optimizedInfo.size / optimizationResult.originalInfo.size) * 100).toFixed(1),
                        taskType: taskType
                    });
                }
            } else {
                logger.debug('图片无需优化，使用原始数据');
            }
        } catch (error) {
            logger.warn('图片优化失败，使用原始数据:', error.message);
        }

        // 获取当前provider和model信息用于错误报告
        const currentProviderModel = configManager.getCurrentProviderModel();
        if (currentProviderModel &&
            currentProviderModel !== 'YOUR_PROVIDER-YOUR_MODEL' &&
            typeof currentProviderModel === 'string' &&
            currentProviderModel.trim() !== '') {
            const knownProviders = ['moonshot', 'tencent', 'zai'];
            for (const provider of knownProviders) {
                if (currentProviderModel.startsWith(provider + '-')) {
                    providerInfo = provider;
                    modelInfo = currentProviderModel; // 使用完整的模型ID
                    break;
                }
            }
        }

        // 调用LLM API进行图片分析
        const response = await callLLMApi(providerConfig, currentModel, imageData, prompt);

        return response;
    } catch (error) {
        console.error(`图片分析失败 [Provider: ${providerInfo}, Model: ${modelInfo}]:`, error.message);

        // 记录错误日志
        errorLogger.logApiError('analyze_image', providerInfo, modelInfo, error, imageData);

        return `图片分析失败: ${error.message}`;
    }
}

/**
 * 根据提供商名称获取相应配置
 * @param {string} provider - 提供商名称
 * @returns {Object} - 提供商配置
 */
function getProviderConfig(provider) {
    const providerConfig = configManager.getProvider(provider);
    if (!providerConfig) {
        throw new Error(`未找到提供商${provider}的配置，请检查settings.json中的${provider}配置`);
    }

    if (!providerConfig.base || !providerConfig.api_key) {
        throw new Error(`提供商${provider}配置不完整，需要base和api_key字段`);
    }

    return providerConfig;
}

/**
 * 调用LLM API
 * @param {Object} config - 提供商配置
 * @param {string} model - 模型名称
 * @param {string} imageData - 图片base64数据
 * @param {string} prompt - 提示语
 * @returns {Promise<string>} - API响应
 */
async function callLLMApi(config, model, imageData, prompt) {

    const requestBody = {
        model: model,
        messages: [
            {
                role: "user",
                content: [
                    {
                        type: "text",
                        text: prompt
                    },
                    {
                        type: "image_url",
                        image_url: {
                            url: imageData.startsWith('data:image/') ? imageData : `data:image/jpeg;base64,${imageData}`
                        }
                    }
                ]
            }
        ],
        max_tokens: 2000,
        temperature: 0.7
    };

    // 检查是否需要使用Moonshot适配器
    let finalRequestBody = requestBody;
    if (MoonshotAdapter.isMoonshotApi(config.base)) {
        finalRequestBody = MoonshotAdapter.transformRequest(requestBody);
        console.log('🔄 使用Moonshot API适配器转换请求格式');
    }

    // 使用智能超时管理
        const imageInfo = await advancedImageOptimizer.parseImage(imageData);
        const promptLength = prompt ? prompt.length : 0;

        const smartTimeout = timeoutManager.getSmartTimeout('singleImage', {
            provider: config.base.replace(/\/[^\/]*$/, '/***'),
            model: model,
            imageSize: imageInfo.size || 0,
            promptLength: promptLength,
            taskType: 'singleImage'
        });

        logger.debug(`使用智能超时: ${smartTimeout}ms (图片: ${imageInfo.sizeMB}MB, 提示词: ${promptLength}字符)`);

        const context = {
            taskType: 'singleImage',
            provider: config.base.replace(/\/[^\/]*$/, '/***'),
            model: model,
            description: '单图片分析'
        };

        const apiPromise = fetch(`${config.base}/chat/completions`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${config.api_key}`
            },
            body: JSON.stringify(finalRequestBody)
        });

        try {
            const response = await timeoutManager.createTimeoutPromise(apiPromise, smartTimeout, context);

            if (!response.ok) {
                const errorText = await response.text();
                throw new Error(`API调用失败 [Provider: ${config.base.replace(/\/[^\/]*$/, '/***')}, Model: ${model}] (${response.status}): ${errorText}`);
            }

            let result = await response.json();

            // 如果是Moonshot API，转换响应格式
            if (MoonshotAdapter.isMoonshotApi(config.base)) {
                result = MoonshotAdapter.transformResponse(result);
                console.log('🔄 使用Moonshot API适配器转换响应格式');
            }

            if (result.choices && result.choices.length > 0) {
                // 提取token使用情况
                const usage = result.usage;
                if (usage) {
                    const inputTokens = usage.prompt_tokens || 0;
                    const outputTokens = usage.completion_tokens || 0;
                    const totalTokens = usage.total_tokens || 0;
                    logger.debug(`Token消耗 [Model: ${model}]: 输入=${inputTokens}, 输出=${outputTokens}, 总计=${totalTokens}`);
                } else {
                    logger.debug(`API未返回token使用信息 [Model: ${model}]`);
                }

                return result.choices[0].message.content;
            } else {
                throw new Error(`API返回格式异常 [Provider: ${config.base.replace(/\/[^\/]*$/, '/***')}, Model: ${model}]，未找到分析结果`);
            }
        } catch (error) {
            // 重新抛出其他错误，这些错误已经包含了provider和model信息
            throw error;
        }
}

/**
 * 将超时的模型移动到provider模型列表的末尾
 * @param {string} provider - 服务商名称
 * @param {string} model - 模型名称
 * @returns {Promise<boolean>} - 是否成功移动
 */
async function moveModelToEnd(provider, model) {
    try {
        const providerConfig = configManager.getProvider(provider);
        if (!providerConfig || !providerConfig.models || !Array.isArray(providerConfig.models)) {
            return false;
        }

        const models = providerConfig.models;
        const modelIndex = models.findIndex(m => {
            if (typeof m === 'string') {
                return m === model;
            } else if (m && typeof m === 'object') {
                return m.id === model || m.name === model;
            }
            return false;
        });

        if (modelIndex > -1) {
            // 移除超时的模型并添加到末尾
            const [movedModel] = models.splice(modelIndex, 1);
            models.push(movedModel);

            // 更新provider配置
            providerConfig.models = models;
            configManager.updateProvider(provider, providerConfig);
            configManager.saveConfig();

            logger.debug(`[重试机制] 模型 ${provider}-${model} 因超时被移动到列表末尾`);
            return true;
        }

        return false;
    } catch (error) {
        console.error(`移动模型失败:`, error.message);
        return false;
    }
}

/**
 * 将超时的provider移动到providers列表的末尾
 * @param {string} provider - 服务商名称
 * @returns {Promise<boolean>} - 是否成功移动
 */
async function moveProviderToEnd(provider) {
    try {
        const providers = configManager.getProviders();
        if (!providers || Object.keys(providers).length === 0) {
            return false;
        }

        const providerNames = Object.keys(providers);
        if (!providerNames.includes(provider)) {
            return false;
        }

        // 重新排序providers（移动指定provider到末尾）
        const reorderedProviders = {};
        providerNames.forEach(name => {
            if (name !== provider) {
                reorderedProviders[name] = providers[name];
            }
        });
        reorderedProviders[provider] = providers[provider];

        // 更新配置
        configManager.set('providers', reorderedProviders);
        logger.debug(`[重试机制] 服务商 ${provider} 因所有模型超时被移动到列表末尾`);
        return true;

        return false;
    } catch (error) {
        console.error(`移动服务商失败:`, error.message);
        return false;
    }
}

/**
 * 检查是否为auto模式
 * @returns {boolean} - 是否为auto模式
 */
function isAutoMode() {
    const currentProviderModel = configManager.getCurrentProviderModel();
    return currentProviderModel === 'auto';
}

/**
 * 带重试机制的API调用
 * @param {Object} config - 服务商配置
 * @param {string} model - 模型名称
 * @param {string} imageData - 图片数据
 * @param {string} prompt - 提示语
 * @param {string} provider - 服务商名称
 * @returns {Promise<string>} - 分析结果
 */
async function callLLMApiWithRetry(config, model, imageData, prompt, provider) {
    try {
        return await callLLMApi(config, model, imageData, prompt);
    } catch (error) {
        // 检查是否为超时错误
        if (error.message.includes('请求超时') || error.message.includes('timeout')) {
            logger.debug(`[重试机制] 检测到模型 ${provider}-${model} 超时`);

            // 移动超时模型到列表末尾
            await moveModelToEnd(provider, model);

            // 如果是auto模式，尝试重试
            if (isAutoMode()) {
                const availableModels = getAvailableModels(provider);
                if (availableModels.length > 0) {
                    const newModel = availableModels[0];
                    logger.debug(`[重试机制] Auto模式：切换到模型 ${provider}-${newModel} 进行重试`);

                    // 更新当前使用的模型
                    configManager.setCurrentProviderModel(`${provider}-${newModel}`);

                    try {
                        const newConfig = getProviderConfig(provider);
                        return await callLLMApi(newConfig, newModel, imageData, prompt);
                    } catch (retryError) {
                        // 如果重试也超时，继续处理
                        if (retryError.message.includes('请求超时') || retryError.message.includes('timeout')) {
                            logger.debug(`[重试机制] 重试模型 ${provider}-${newModel} 也超时`);
                            await moveModelToEnd(provider, newModel);

                            // 检查是否还有其他模型可重试
                            const remainingModels = getAvailableModels(provider);
                            if (remainingModels.length === 0) {
                                logger.debug(`[重试机制] 服务商 ${provider} 的所有模型都已超时，移动服务商到列表末尾`);
                                await moveProviderToEnd(provider);
                                throw new Error(`服务商 ${provider} 的所有模型都超时，请检查网络连接或稍后重试`);
                            }
                        }
                        throw retryError;
                    }
                }
            }
        }
        throw error;
    }
}

/**
 * 从current_provider_model环境变量中获取当前服务商
 * @returns {string|null} - 当前服务商名称
 */
function getCurrentProvider() {
    const currentProviderModel = configManager.getCurrentProviderModel();
    if (!currentProviderModel || currentProviderModel === 'YOUR_PROVIDER-YOUR_MODEL' || currentProviderModel === 'auto') {
        // 当没有正确配置或设置为auto时，返回第一个有效的provider
        const availableProviders = getAvailableProviders();
        if (availableProviders.length > 0) {
            return availableProviders[0];
        }
        return null;
    }

    const availableProviders = getAvailableProviders();

    // 情况1: 标准格式 "provider-model"
    for (const provider of availableProviders) {
        if (currentProviderModel.startsWith(provider + '-')) {
            return provider;
        }
    }

    // 情况2a: 只提供了provider名称
    if (availableProviders.includes(currentProviderModel)) {
        return currentProviderModel;
    }

    // 情况2b: 只提供了model名称，需要找到第一个包含此model的provider
    for (const provider of availableProviders) {
        const models = getAvailableModels(provider);
        if (models.includes(currentProviderModel)) {
            return provider;
        }
    }

    return null;
}

/**
 * 从current_provider_model环境变量中获取当前模型
 * @returns {string|null} - 当前模型名称
 */
function getCurrentModel() {
    const currentProviderModel = configManager.getCurrentProviderModel();
    if (!currentProviderModel || currentProviderModel === 'YOUR_PROVIDER-YOUR_MODEL' || currentProviderModel === 'auto') {
        // 当没有正确配置或设置为auto时，返回第一个有效provider的第一个视觉模型
        const availableProviders = getAvailableProviders();
        if (availableProviders.length > 0) {
            const visionModel = getFirstVisionModel(availableProviders[0]);
            if (visionModel) {
                return visionModel;
            }
            // 如果没有找到视觉模型，返回第一个模型（向后兼容）
            const models = getAvailableModels(availableProviders[0]);
            return models.length > 0 ? models[0] : null;
        }
        return null;
    }

    const availableProviders = getAvailableProviders();

    // 情况1: 标准格式 "provider-model"
    for (const provider of availableProviders) {
        if (currentProviderModel.startsWith(provider + '-')) {
            // 返回完整的模型ID，而不是去掉前缀
            return currentProviderModel;
        }
    }

    // 情况2a: 只提供了provider名称，使用该provider的第一个视觉模型
    if (availableProviders.includes(currentProviderModel)) {
        const visionModel = getFirstVisionModel(currentProviderModel);
        if (visionModel) {
            return visionModel;
        }
        // 如果没有找到视觉模型，返回第一个模型（向后兼容）
        const models = getAvailableModels(currentProviderModel);
        return models.length > 0 ? models[0] : null;
    }

    // 情况2b: 只提供了model名称，直接返回
    for (const provider of availableProviders) {
        const models = getAvailableModels(provider);
        if (models.includes(currentProviderModel)) {
            return currentProviderModel;
        }
    }

    return null;
}

/**
 * 验证current_provider_model配置是否有效
 * @param {boolean} testMode - 是否为测试模式
 * @returns {Object} - 验证结果
 */
function validateCurrentProviderModel(testMode = false) {
    // 重新加载配置以获取最新更改
    try {
        configManager.reloadConfig();
    } catch (error) {
        // 如果重新加载失败，继续使用现有配置
    }

    const currentProviderModel = configManager.getCurrentProviderModel();

    // 处理auto模式或未配置的情况
    if (!currentProviderModel || currentProviderModel === 'YOUR_PROVIDER-YOUR_MODEL' || currentProviderModel === 'auto') {
        // 使用第一个有效provider的第一个视觉模型
        const availableProviders = getAvailableProviders();
        if (availableProviders.length > 0) {
            const firstProvider = availableProviders[0];
            const models = getAvailableModels(firstProvider);
            if (models.length > 0) {
                // 优先选择视觉模型
                const visionModels = filterVisionModels(models);
                const selectedModel = visionModels.length > 0 ? visionModels[0] : models[0];

                return {
                    valid: true,
                    provider: firstProvider,
                    model: selectedModel,
                    availableModels: models,
                    originalFormat: currentProviderModel === 'auto' ? 'auto' : 'default'
                };
            }
        }

        return {
            valid: false,
            error: '未配置current_provider_model且没有可用的provider配置',
            provider: null,
            model: null
        };
    }

    const availableProviders = getAvailableProviders();
    let currentProvider = null;
    let currentModel = null;
    let originalFormat = 'standard'; // 记录原始格式类型

    // 情况1: 标准格式 "provider-model"
    for (const provider of availableProviders) {
        if (currentProviderModel.startsWith(provider + '-')) {
            currentProvider = provider;
            currentModel = currentProviderModel.substring(provider.length + 1); // 去掉provider前缀
            originalFormat = 'provider-model';
            break;
        }
    }

    // 情况2a: 只提供了provider名称
    if (!currentProvider && availableProviders.includes(currentProviderModel)) {
        currentProvider = currentProviderModel;
        const models = getAvailableModels(currentProvider);
        if (models.length > 0) {
            // 优先选择视觉模型
            const visionModels = filterVisionModels(models);
            currentModel = visionModels.length > 0 ? visionModels[0] : models[0];
        } else {
            currentModel = null;
        }
        originalFormat = 'provider-only';
    }

    // 情况2b: 只提供了model名称
    if (!currentProvider && !currentModel) {
        for (const provider of availableProviders) {
            const models = getAvailableModels(provider);
            if (models.includes(currentProviderModel)) {
                currentProvider = provider;
                currentModel = currentProviderModel;
                originalFormat = 'model-only';
                break;
            }
        }
    }

    if (!currentProvider || !currentModel) {
        return {
            valid: false,
            error: `current_provider_model配置无效: "${currentProviderModel}"。支持的格式: 1) "provider-model" 2) "provider" 3) "model"`,
            provider: currentProvider,
            model: currentModel,
            originalFormat: originalFormat
        };
    }

    // 检查provider是否存在配置
    try {
        const providerConfig = getProviderConfig(currentProvider);
        if (!providerConfig.base || !providerConfig.api_key) {
            return {
                valid: false,
                error: `服务商${currentProvider}配置不完整，请检查${currentProvider}配置中的base和api_key字段`,
                provider: currentProvider,
                model: currentModel,
                originalFormat: originalFormat
            };
        }
    } catch (error) {
        return {
            valid: false,
            error: `服务商${currentProvider}配置错误: ${error.message}`,
            provider: currentProvider,
            model: currentModel,
            originalFormat: originalFormat
        };
    }

    // 检查模型是否在可用模型列表中
    const availableModels = getAvailableModels(currentProvider);
    if (!availableModels.includes(currentModel)) {
        // 在测试模式下，如果是常见的测试模型，允许通过验证
        if (testMode && (currentModel === 'glm-4.5v' || currentModel === 'hunyuan-vision' || currentModel === 'moonshot-v1-8k-vision-preview')) {
            // 测试模式下允许常见的测试模型通过验证
            console.log(`[测试模式] 允许使用测试模型: ${currentProvider}-${currentModel}`);
        } else {
            return {
                valid: false,
                error: `模型${currentModel}在服务商${currentProvider}中不存在或未启用。可用模型: ${availableModels.join(', ')}`,
                provider: currentProvider,
                model: currentModel,
                availableModels: availableModels,
                originalFormat: originalFormat
            };
        }
    }

    return {
        valid: true,
        provider: currentProvider,
        model: currentModel,
        availableModels: availableModels,
        originalFormat: originalFormat
    };
}

/**
 * 获取指定服务商的可用视觉模型列表
 * @param {string} provider - 服务商名称
 * @returns {string[]} - 可用模型列表
 */
/**
 * 获取指定provider的第一个视觉模型
 * @param {string} provider - 服务商名称
 * @returns {string|null} - 第一个视觉模型名称
 */
function getFirstVisionModel(provider) {
    try {
        const models = getAvailableModels(provider);

        // 优先选择包含vision关键词的模型
        const visionModels = models.filter(model =>
            model.toLowerCase().includes('vision')
        );

        if (visionModels.length > 0) {
            return visionModels[0];
        }

        // 如果没有vision模型，选择包含v的模型（如glm-4.5v）
        const vModels = models.filter(model =>
            model.toLowerCase().endsWith('v') && !model.includes('4v') // 避免与4v重复
        );

        if (vModels.length > 0) {
            return vModels[0];
        }

        // 选择包含4v的模型（如glm-4.5v）
        const fourVModels = models.filter(model =>
            model.toLowerCase().includes('4v')
        );

        if (fourVModels.length > 0) {
            return fourVModels[0];
        }

        // 最后选择包含image的模型
        const imageModels = models.filter(model =>
            model.toLowerCase().includes('image')
        );

        if (imageModels.length > 0) {
            return imageModels[0];
        }

        return null;
    } catch (error) {
        console.error(`获取${provider}的视觉模型失败:`, error.message);
        return null;
    }
}

/**
 * 静态模型列表 - 已知可用的模型作为回退机制
 * 这些模型即使在API返回的列表中缺失也实际可用
 */
const STATIC_FALLBACK_MODELS = {
    zai: [
        'glm-4.5v',    // 智谱AI视觉模型 - 唯一视觉模型
          'glm-4-air'    // 智谱AI轻量模型
    ],
    tencent: [
        'hunyuan-vision',           // 腾讯混元视觉模型
        'hunyuan-turbo-vision',     // 腾讯混元加速视觉模型
        'hunyuan-t1-vision',        // 腾讯混元T1视觉模型
        'hunyuan-large-vision',     // 腾讯混元大型视觉模型
        'hunyuan-turbos-vision-20250619',  // 腾讯混元Turbos视觉模型
        'hunyuan-t1-vision-20250619',      // 腾讯混元T1视觉模型(2025-06-19)
        'hunyuan-vision-7b-20250720',      // 腾讯混元视觉7B模型
        'hunyuan-t1-vision-20250916'       // 腾讯混元T1视觉模型(2025-09-16)
    ],
    moonshot: [
        'moonshot-v1-8k-vision-preview',    // Moonshot 8K视觉预览模型
        'moonshot-v1-32k-vision-preview',   // Moonshot 32K视觉预览模型
        'moonshot-v1-128k-vision-preview'   // Moonshot 128K视觉预览模型
    ]
};

function getAvailableModels(provider) {
    try {
        const providerConfig = configManager.getProvider(provider);
        if (!providerConfig) {
            console.log(`   未找到提供商${provider}的配置，使用静态回退模型`);
            return STATIC_FALLBACK_MODELS[provider] || [];
        }

        if (!providerConfig.models || !Array.isArray(providerConfig.models)) {
            console.log(`   提供商${provider}配置中缺少models数组字段，使用静态回退模型`);
            return STATIC_FALLBACK_MODELS[provider] || [];
        }

        // 处理混合格式：既支持对象格式的模型，也支持字符串格式的模型
        const configuredModels = [];
        for (const model of providerConfig.models) {
            if (typeof model === 'string') {
                // 字符串格式的模型，直接添加
                if (model.trim()) {
                    configuredModels.push(model.trim());
                }
            } else if (typeof model === 'object' && model.id) {
                // 对象格式的模型，提取id字段
                if (model.id && typeof model.id === 'string' && model.id.trim()) {
                    configuredModels.push(model.id.trim());
                }
            }
        }

        // 合并配置的模型和静态回退模型
        const fallbackModels = STATIC_FALLBACK_MODELS[provider] || [];
        const allModels = [...new Set([...configuredModels, ...fallbackModels])]; // 去重合并

        // 如果有新的静态模型被添加，输出提示信息
        const newModels = fallbackModels.filter(model => !configuredModels.includes(model));
        if (newModels.length > 0) {
            console.log(`   为${provider}添加静态回退模型: [${newModels.join(', ')}]`);
        }

        return allModels;
    } catch (error) {
        if (error instanceof SyntaxError) {
            console.log(`   解析${provider}模型配置失败 - JSON格式错误: ${error.message}，使用静态回退模型`);
        } else {
            console.log(`   解析${provider}模型配置失败: ${error.message}，使用静态回退模型`);
        }
        return STATIC_FALLBACK_MODELS[provider] || [];
    }
}

/**
 * 获取所有可用的服务商列表
 * @returns {string[]} - 服务商名称列表
 */
function getAvailableProviders() {
    try {
        // 使用JSON配置中的providers
        const providers = configManager.getProviders();
        if (providers && Object.keys(providers).length > 0) {
            return Object.keys(providers).filter(provider => typeof provider === 'string' && provider.trim());
        }

        // 如果没有providers配置，则使用配置中的providers
        const fallbackProviders = [];
        const commonProviderNames = ['moonshot', 'tencent', 'zai', 'openai', 'anthropic', 'google'];

        for (const provider of commonProviderNames) {
            if (providers && providers[provider]) {
                fallbackProviders.push(provider);
            }
        }

        return fallbackProviders;
    } catch (error) {
        console.error('获取服务商列表失败:', error.message);
        return [];
    }
}

/**
 * 更新providers配置列表
 * @returns {Promise<Object>} - 更新结果
 */
async function updateProvidersList() {
    try {
        // 检查是否在测试环境中
        if (process.env.NODE_ENV === 'test' ||
            process.env.JEST_WORKER_ID !== undefined ||
            process.env.npm_config_argv?.includes('test')) {
            // 测试环境中，返回默认的测试providers
            logger.debug('[测试环境] 返回默认providers列表');
            return {
                success: true,
                providers: ['moonshot', 'tencent', 'zai'],
                count: 3,
                message: '测试环境：返回默认providers配置'
            };
        }

        // 从JSON配置中获取所有可用的providers
        const providers = configManager.getProviders();
        const availableProviders = [];

        for (const [providerName, providerConfig] of Object.entries(providers)) {
            if (providerConfig.base && providerConfig.api_key && providerConfig.api_key.trim() !== '') {
                availableProviders.push(providerName);
            }
        }

        return {
            success: true,
            providers: availableProviders,
            count: availableProviders.length,
            message: `成功获取providers列表，共${availableProviders.length}个可用服务商`
        };
    } catch (error) {
        return {
            success: false,
            error: error.message,
            message: `获取providers配置失败: ${error.message}`
        };
    }
}

/**
 * 列出当前LLM服务可用的视觉大模型列表
 * @returns {Object} - 包含所有服务商和其可用模型的对象
 */
function list_models() {
    const providers = getAvailableProviders();
    const result = {};

    providers.forEach(provider => {
        try {
            const config = getProviderConfig(provider);
            const availableModels = getAvailableModels(provider);

            result[provider] = {
                available: !!(config.base && config.api_key),
                models: availableModels,
                baseUrl: config.base ? config.base.replace(/\/[^\/]*$/, '/***') : null // 隐藏完整URL
            };
        } catch (error) {
            result[provider] = {
                available: false,
                models: [],
                baseUrl: null,
                error: error.message
            };
        }
    });

    const currentProvider = getCurrentProvider();
    const currentModel = getCurrentModel();

    return {
        providers: result,
        current: {
            provider: currentProvider,
            model: currentModel
        }
    };
}

/**
 * 改进的use_model函数，支持多种格式
 * @param {string} providerModel - 格式为 "provider-model"、"provider"、"model" 或分别传入provider和model
 * @param {string} model - 可选，如果第一个参数是provider则传入model
 * @returns {Promise<Object>} - 切换结果
 */
async function use_model(providerModel, model = null) {
    try {
        let targetProvider, targetModel;
        const availableProviders = getAvailableProviders();

        if (model === null) {
            // 只传入一个参数，可能是 "provider-model"、"provider" 或 "model"

            // 情况1: 标准格式 "provider-model"
            for (const provider of availableProviders) {
                if (providerModel.startsWith(provider + '-')) {
                    targetProvider = provider;
                    targetModel = providerModel.substring(provider.length + 1);
                    break;
                }
            }

            // 情况2a: 只提供了provider名称
            if (!targetProvider && availableProviders.includes(providerModel)) {
                targetProvider = providerModel;
                const models = getAvailableModels(targetProvider);
                if (models.length === 0) {
                    throw new Error(`服务商${targetProvider}没有可用的模型`);
                }
                targetModel = models[0]; // 使用第一个模型
            }

            // 情况2b: 只提供了model名称
            if (!targetProvider && !targetModel) {
                for (const provider of availableProviders) {
                    const models = getAvailableModels(provider);
                    if (models.includes(providerModel)) {
                        targetProvider = provider;
                        targetModel = providerModel;
                        break;
                    }
                }
            }

            if (!targetProvider || !targetModel) {
                throw new Error(`参数格式错误。支持的格式: 1) "provider-model" 2) "provider" 3) "model"。当前值: "${providerModel}"`);
            }
        } else {
            // 分别传入provider和model
            targetProvider = providerModel;
            targetModel = model;
        }

        // 获取目标服务商的可用模型
        const availableModels = getAvailableModels(targetProvider);

        // 验证模型是否可用
        if (!availableModels.includes(targetModel)) {
            throw new Error(`模型${targetModel}在${targetProvider}服务商中不可用。可用模型: ${availableModels.join(', ')}`);
        }

        // 更新环境变量为provider-model格式
        configManager.setCurrentProviderModel(`${targetProvider}-${targetModel}`);

        return {
            success: true,
            provider: targetProvider,
            model: targetModel,
            message: `成功切换到${targetProvider}服务商的${targetModel}模型`
        };
    } catch (error) {
        return {
            success: false,
            error: error.message,
            message: `切换模型失败: ${error.message}`
        };
    }
}


/**
 * 新增OpenAI兼容的LLM服务到JSON配置中
 * @param {string} providerName - 服务商名称
 * @param {string} baseUrl - API基础URL
 * @param {string} apiKey - API密钥
 * @returns {Promise<Object>} - 添加结果
 */
async function add_provider(providerName, baseUrl, apiKey) {
    try {
        // 验证服务商名称格式
        if (!/^[a-zA-Z0-9_-]+$/.test(providerName)) {
            throw new Error('服务商名称只能包含字母、数字、下划线和连字符');
        }

        // 验证URL格式
        try {
            new URL(baseUrl);
        } catch {
            throw new Error('baseUrl格式无效');
        }

        // 检查服务商是否已存在
        const existingConfig = configManager.getProvider(providerName);
        if (existingConfig) {
            throw new Error(`服务商${providerName}已存在`);
        }

        // 获取模型列表
        const availableModels = await fetchProviderModels(baseUrl, apiKey);
        const visionModels = filterVisionModels(availableModels);

        if (visionModels.length === 0) {
            throw new Error('该服务商未找到支持视觉分析的模型');
        }

        // 对于新provider，直接使用API获取的视觉模型作为初始配置
        const initialModels = visionModels;

        // 构建新的JSON配置
        const newConfig = {
            base: baseUrl,
            api_key: apiKey,
            models: initialModels,
            timeout: 30000,
            max_retries: 3
        };

        // 使用配置管理器添加新的provider
        configManager.addProvider(providerName, newConfig);

        // 自动更新providers列表
        await updateProvidersList();

        return {
            success: true,
            provider: providerName,
            baseUrl: baseUrl,
            availableModels: visionModels,
            totalModels: availableModels.length,
            message: `成功添加服务商${providerName}，共${visionModels.length}个视觉模型可用`
        };
    } catch (error) {
        return {
            success: false,
            error: error.message,
            message: `添加服务商${providerName}失败: ${error.message}`
        };
    }
}

/**
 * 批量为provider新增多个视觉模型到.env文件
 * @param {string} provider - 服务商名称
 * @param {string[]} modelNames - 新模型名称数组
 * @returns {Promise<Object>} - 添加结果
 */
/**
 * 已废弃: addNewModelsToEnv - 请使用JsonConfigManager替代
 * 使用方法: configManager.addModel(provider, modelObject)
 */
async function addNewModelsToEnv(provider, modelNames) {
    console.warn('⚠️ addNewModelsToEnv已废弃，请使用JSON配置系统');
    // 使用JSON配置管理器
    const JsonConfigManager = require('./lib/config/json-config-manager');
    const ConfigPathResolver = require('./lib/config/config-path-resolver');

    const pathResolver = new ConfigPathResolver();
    const configManager = new JsonConfigManager(path.join(__dirname, '.'));

    const config = configManager.loadConfig();
    if (!config.providers[provider]) {
        throw new Error(`Provider ${provider} 不存在`);
    }

    modelNames.forEach(modelName => {
        const modelObject = {
            id: modelName,
            name: modelName,
            type: 'vision',
            capabilities: ['image_analysis'],
            max_tokens: 4096,
            supports_vision: true,
            enabled: true
        };
        configManager.addModel(provider, modelObject);
    });
}

/**
 * 为已有provider新增可用模型
 * @param {string} provider - 服务商名称
 * @param {string} modelName - 模型名称
 * @returns {Promise<Object>} - 添加结果
 */
/**
 * 已废弃: add_model_for_provider - 请使用JsonConfigManager替代
 * 使用方法: configManager.addModel(provider, modelObject)
 */
async function add_model_for_provider(provider, modelName) {
    console.warn('⚠️ add_model_for_provider已废弃，请使用JSON配置系统');
    const JsonConfigManager = require('./lib/config/json-config-manager');
    const ConfigPathResolver = require('./lib/config/config-path-resolver');

    const pathResolver = new ConfigPathResolver();
    const configManager = new JsonConfigManager(path.join(__dirname, '.'));

    const modelObject = {
        id: modelName,
        name: modelName,
        type: 'vision',
        capabilities: ['image_analysis'],
        max_tokens: 4096,
        supports_vision: true,
        enabled: true
    };

    configManager.addModel(provider, modelObject);
}

/**
 * 合并API获取的视觉模型和配置中已有的模型
 * @param {string} provider - 服务商名称
 * @param {Array} apiVisionModels - 从API获取的视觉模型列表
 * @returns {Object} - 合并结果 {mergedModels: Array, newModels: Array}
 */
function mergeVisionModels(provider, apiVisionModels) {
    try {
        // 获取配置中已有的模型列表
        const existingModels = getAvailableModels(provider);

        // 如果获取已有模型失败（provider不存在），返回API模型
        if (!existingModels || existingModels.length === 0) {
            console.log(`${provider} 配置中无已有模型，使用API获取的${apiVisionModels.length}个模型`);
            return {
                success: true,
                mergedModels: apiVisionModels,
                newModels: apiVisionModels,
                existingModels: [],
                totalExisting: 0,
                totalNew: apiVisionModels.length,
                totalMerged: apiVisionModels.length
            };
        }

        // 去重：API模型中不在配置中的模型
        const newModels = apiVisionModels.filter(model =>
            !existingModels.includes(model)
        );

        // 合并后的模型列表（保持原有顺序，新发现的模型追加在后面）
        const mergedModels = [...existingModels, ...newModels];

        console.log(`${provider} 模型合并结果: 配置中已有${existingModels.length}个，新发现${newModels.length}个，合并后共${mergedModels.length}个视觉模型`);

        if (newModels.length > 0) {
            console.log(`${provider} 新发现的视觉模型: ${newModels.join(', ')}`);
        }

        return {
            success: true,
            mergedModels: mergedModels,
            newModels: newModels,
            existingModels: existingModels,
            totalExisting: existingModels.length,
            totalNew: newModels.length,
            totalMerged: mergedModels.length
        };
    } catch (error) {
        console.error(`合并${provider}视觉模型失败:`, error.message);
        return {
            success: false,
            error: error.message,
            mergedModels: apiVisionModels,
            newModels: [],
            existingModels: [],
            totalExisting: 0,
            totalNew: 0,
            totalMerged: apiVisionModels.length
        };
    }
}

/**
 * 更新provider配置中的models列表
 * @param {string} provider - 服务商名称
 * @param {Array} updatedModels - 更新后的模型列表
 * @param {string} envPath - 可选的自定义环境文件路径
 * @returns {Promise<Object>} - 更新结果
 */
/**
 * 已废弃: updateProviderModels - 请使用JsonConfigManager替代
 * 使用方法: configManager.addModel(provider, modelObject)
 */
async function updateProviderModels(provider, updatedModels, envPath = null) {
    console.warn('⚠️ updateProviderModels已废弃，请使用JSON配置系统');
    const JsonConfigManager = require('./lib/config/json-config-manager');
    const ConfigPathResolver = require('./lib/config/config-path-resolver');

    const pathResolver = new ConfigPathResolver();
    const configManager = new JsonConfigManager(path.join(__dirname, '.'));

    const config = configManager.loadConfig();
    if (!config.providers[provider]) {
        throw new Error(`Provider ${provider} 不存在`);
    }

    // 清空现有模型
    config.providers[provider].models = [];

    // 添加新模型
    updatedModels.forEach(model => {
        const modelObject = {
            id: model.id || model,
            name: model.name || model,
            type: model.type || 'vision',
            capabilities: model.capabilities || ['image_analysis'],
            max_tokens: model.max_tokens || 4096,
            supports_vision: model.supports_vision !== false,
            enabled: model.enabled !== false
        };
        configManager.addModel(provider, modelObject);
    });
}

/**
 * 更新服务商配置到.env文件
 * @param {string} provider - 服务商名称
 * @param {Object} config - 服务商配置
 * @returns {Promise<boolean>} - 是否成功更新
 */
/**
 * 已废弃: updateProviderConfigInEnv - 请使用JsonConfigManager替代
 * 使用方法: configManager.updateProvider(provider, providerConfig)
 */
async function updateProviderConfigInEnv(provider, config) {
    console.warn('⚠️ updateProviderConfigInEnv已废弃，请使用JSON配置系统');
    const JsonConfigManager = require('./lib/config/json-config-manager');
    const ConfigPathResolver = require('./lib/config/config-path-resolver');

    const pathResolver = new ConfigPathResolver();
    const configManager = new JsonConfigManager(path.join(__dirname, '.'));

    const providerConfig = {
        base: config.base || config.baseUrl,
        api_key: config.api_key || config.apiKey,
        models: config.models || [],
        timeout: config.timeout || 30000,
        max_retries: config.max_retries || 3
    };

    configManager.updateProvider(provider, providerConfig);
}

/**
 * 更新providers配置到.env文件
 * @param {Array} providers - 服务商列表
 * @returns {Promise<boolean>} - 是否成功更新
 */
/**
 * 已废弃: updateProvidersConfigInEnv - 请使用JsonConfigManager替代
 * 使用方法: configManager.saveConfig(config)
 */
async function updateProvidersConfigInEnv(providers) {
    console.warn('⚠️ updateProvidersConfigInEnv已废弃，请使用JSON配置系统');
    const JsonConfigManager = require('./lib/config/json-config-manager');
    const ConfigPathResolver = require('./lib/config/config-path-resolver');

    const pathResolver = new ConfigPathResolver();
    const configManager = new JsonConfigManager(path.join(__dirname, '.'));

    const config = configManager.loadConfig();
    config.providers = providers;
    configManager.saveConfig(config);
}

/**
 * 从服务商API获取模型列表
 * @param {string} baseUrl - API基础URL
 * @param {string} apiKey - API密钥
 * @returns {Promise<Array>} - 模型列表
 */
async function fetchProviderModels(baseUrl, apiKey) {
    try {

        const response = await fetch(`${baseUrl}/models`, {
            method: 'GET',
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Content-Type': 'application/json'
            }
        });

        if (!response.ok) {
            throw new Error(`API调用失败 (${response.status}): ${response.statusText}`);
        }

        const result = await response.json();

        // 处理不同API格式的响应
        let models = [];
        if (result.data && Array.isArray(result.data)) {
            // OpenAI格式
            models = result.data.map(model => model.id);
        } else if (result.models && Array.isArray(result.models)) {
            // 其他格式
            models = result.models.map(model => model.id || model);
        } else if (Array.isArray(result)) {
            // 直接是数组格式
            models = result.map(model => model.id || model);
        } else {
            throw new Error('无法解析模型列表响应格式');
        }

        return models;
    } catch (error) {
        console.error('获取模型列表失败:', error.message);
        throw new Error(`获取模型列表失败: ${error.message}`);
    }
}

/**
 * 过滤出支持视觉分析的模型
 * @param {Array} models - 所有模型列表
 * @returns {Array} - 支持视觉的模型列表
 */
function filterVisionModels(models) {
    const visionKeywords = [
        'vision', 'visual', 'Vi', 'VL', 'CLIP', 'ALIGN', 'VLM', 'MultiModal', 'MM',
        'multimodal', 'image', 'gpt-4-vision', 'claude-3', 'gemini-pro-vision',
        'qwen-vl', 'yi-vl', 'deepseek-vl', 'internvl'
    ];

    return models.filter(model => {
        const modelLower = model.toLowerCase();

        // 检查视觉关键词
        if (visionKeywords.some(keyword => modelLower.includes(keyword.toLowerCase()))) {
            return true;
        }

        // 检查特定模式的视觉模型命名
        // GLM模型：glm-4.5v 等
        if (modelLower.includes('glm') && modelLower.includes('v')) {
            return true;
        }

        // 检查其他模型的视觉版本
        if (modelLower.match(/\d+v$/) || modelLower.match(/-\d+v$/)) {
            return true;
        }

        return false;
    });
}

/**
 * 删除指定的模型（通过更新.env中的JSON数组配置）
 * @param {string} providerModel - 格式为 "provider-model"
 * @returns {Promise<Object>} - 删除结果
 */
async function delete_model(providerModel) {
    try {
        // 解析provider-model格式
        const knownProviders = ['moonshot', 'tencent', 'zai'];
        let targetProvider, targetModel;

        for (const provider of knownProviders) {
            if (providerModel.startsWith(provider + '-')) {
                targetProvider = provider;
                targetModel = providerModel.substring(provider.length + 1);
                break;
            }
        }

        if (!targetProvider || !targetModel) {
            throw new Error('provider_model格式错误，应为：provider-model 格式');
        }

        const envPath = path.join(projectRoot, '.env');

        if (!fs.existsSync(envPath)) {
            throw new Error('.env文件不存在');
        }

        // 读取.env文件内容
        let envContent = fs.readFileSync(envPath, 'utf8');
        const lines = envContent.split('\n');

        let modifiedLines = [];
        let foundConfig = false;

        // 更新JSON对象配置中的models数组
        for (let i = 0; i < lines.length; i++) {
            const line = lines[i];

            if (line.startsWith(`${targetProvider}={`)) {
                foundConfig = true;
                try {
                    // 解析现有配置
                    const configMatch = line.match(/^([a-zA-Z0-9_-]+)=({.*})$/);
                    if (configMatch) {
                        const providerName = configMatch[1];
                        const jsonConfig = JSON.parse(configMatch[2]);

                        // 从models数组中移除指定模型
                        if (jsonConfig.models && Array.isArray(jsonConfig.models)) {
                            jsonConfig.models = jsonConfig.models.filter(model => model !== targetModel);
                        }

                        // 生成新的配置行
                        const newConfigLine = `${providerName}=${JSON.stringify(jsonConfig)}`;
                        modifiedLines.push(newConfigLine);
                    } else {
                        modifiedLines.push(line);
                    }
                } catch (error) {
                    throw new Error(`解析${targetProvider}现有配置失败: ${error.message}`);
                }
            } else {
                modifiedLines.push(line);
            }
        }

        if (!foundConfig) {
            throw new Error(`未找到模型${providerModel}的配置或已被删除`);
        }

        // 写回.env文件
        fs.writeFileSync(envPath, modifiedLines.join('\n'));

        // 重新加载环境变量
        configManager.reloadConfig();

        return {
            success: true,
            provider: targetProvider,
            model: targetModel,
            message: `成功删除模型${providerModel}`
        };
    } catch (error) {
        return {
            success: false,
            error: error.message,
            message: `删除模型${providerModel}失败: ${error.message}`
        };
    }
}

/**
 * 删除provider中指定的模型（通过注释掉.env中的模型配置）
 * @param {string} providerModel - 格式为 "provider-model"
 * @returns {Promise<Object>} - 删除结果
 */
async function delete_model_for_provider(providerModel) {
    return await delete_model(providerModel);
}

/**
 * 重新设置已有LLM服务的apiKey
 * @param {string} provider - 服务商名称
 * @param {string} apiKey - 新的API密钥
 * @returns {Promise<Object>} - 设置结果
 */
/**
 * 已废弃: set_provider - 请使用JsonConfigManager替代
 * 使用方法: configManager.updateProvider(provider, {api_key: apiKey})
 */
async function set_provider(provider, apiKey) {
    console.warn('⚠️ set_provider已废弃，请使用JSON配置系统');
    const JsonConfigManager = require('./lib/config/json-config-manager');
    const ConfigPathResolver = require('./lib/config/config-path-resolver');

    const pathResolver = new ConfigPathResolver();
    const configManager = new JsonConfigManager(path.join(__dirname, '.'));

    // 获取或创建provider配置
    const config = configManager.loadConfig();
    if (!config.providers[provider]) {
        throw new Error(`Provider ${provider} 不存在，请先添加provider`);
    }

    // 更新API密钥
    config.providers[provider].api_key = apiKey;
    configManager.saveConfig(config);
}

/**
 * 分析设计截图，返回详细的UI元素描述
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 详细UI元素分析结果
 */
async function analyze_design_screenshot(imgString) {
    try {
        const prompt = promptManager.getPrompt('analyze_design_screenshot');
        if (!prompt) {
            return '错误：未找到analyze_design_screenshot提示词配置';
        }
        return await analyze_image(imgString, prompt);
    } catch (error) {
        throw new Error(`设计截图分析失败: ${error.message}`);
    }
}

/**
 * 提取组件层次结构，描述元素之间的包含关系
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 组件层次结构分析结果
 */
async function extract_component_hierarchy(imgString) {
    try {
        const prompt = promptManager.getPrompt('extract_component_hierarchy');
        if (!prompt) {
            return '错误：未找到extract_component_hierarchy提示词配置';
        }
        return await analyze_image(imgString, prompt);
    } catch (error) {
        return `组件层次结构提取失败: ${error.message}`;
    }
}

/**
 * 获取精确的布局规格，包括间距、对齐方式等
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 布局规格分析结果
 */
async function get_exact_layout_specifications(imgString) {
    try {
        const prompt = promptManager.getPrompt('get_exact_layout_specifications');
        if (!prompt) {
            return '错误：未找到get_exact_layout_specifications提示词配置';
        }
        return await analyze_image(imgString, prompt);
    } catch (error) {
        return `布局规格获取失败: ${error.message}`;
    }
}

/**
 * 识别设计令牌，如颜色、字体、圆角等
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 设计令牌识别结果
 */
async function identify_visual_tokens(imgString) {
    try {
        const prompt = promptManager.getPrompt('identify_visual_tokens');
        if (!prompt) {
            return '错误：未找到identify_visual_tokens提示词配置';
        }
        return await analyze_image(imgString, prompt);
    } catch (error) {
        return `视觉令牌识别失败: ${error.message}`;
    }
}

/**
 * 返回精确的设计分析，避免任何模糊描述
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 精确设计分析结果
 */
async function analyze_design_with_precision(imgString) {
    try {
        const prompt = promptManager.getPrompt('analyze_design_with_precision');
        if (!prompt) {
            return '错误：未找到analyze_design_with_precision提示词配置';
        }
        return await analyze_image(imgString, prompt);
    } catch (error) {
        return `精确设计分析失败: ${error.message}`;
    }
}

/**
 * 对比两幅图片的差异
 * @param {string} imgString1 - 第一张图片的base64编码字符串或文件路径
 * @param {string} imgString2 - 第二张图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 对比分析结果
 */
async function compare_image(imgString1, imgString2) {
    const prompt = promptManager.getPrompt('compare_image');
    if (!prompt) {
        throw new Error('未找到compare_image提示词配置');
    }
    return await compareImagesBase(imgString1, imgString2, prompt, 'compare_image', '图片对比失败');
}

/**
 * 对比两幅图片的差异并返回边界框坐标
 * @param {string} imgString1 - 第一张图片的base64编码字符串或文件路径
 * @param {string} imgString2 - 第二张图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 带边界框坐标的对比分析结果
 */
async function compare_image_with_bounding_boxes(imgString1, imgString2) {
    const prompt = promptManager.getPrompt('compare_image_with_bounding_boxes');
    if (!prompt) {
        throw new Error('未找到compare_image_with_bounding_boxes提示词配置');
    }
    return await compareImagesBase(imgString1, imgString2, prompt, 'compare_image_with_bounding_boxes', '带边界框图片对比失败');
}

/**
 * 列出指定provider的所有可用模型
 * @param {string} provider - 服务商名称
 * @returns {Promise<Object>} - 包含模型列表和元数据的对象
 */
async function list_provider_models(provider) {
    try {
        // 获取provider配置
        const config = getProviderConfig(provider);

        // 设置超时控制
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), 30000); // 30秒超时

        try {
            // 调用OpenAI兼容的models API
            const response = await fetch(`${config.base}/models`, {
                method: 'GET',
                headers: {
                    'Authorization': `Bearer ${config.api_key}`,
                    'Content-Type': 'application/json'
                },
                signal: controller.signal
            });

            clearTimeout(timeoutId);

            if (!response.ok) {
                const errorText = await response.text();
                throw new Error(`获取模型列表失败 [Provider: ${provider}] (${response.status}): ${errorText}`);
            }

            const result = await response.json();

            // 提取模型信息
            let models = [];
            let visionModels = [];

            if (result.data && Array.isArray(result.data)) {
                models = result.data.map(model => ({
                    id: model.id,
                    object: model.object || 'model',
                    created: model.created,
                    owned_by: model.owned_by || 'unknown'
                }));

                // 过滤出支持视觉的模型
                const visionKeywords = ['vision', 'image', 'multimodal', 'gemini', 'vl', 'mm', 'clip', 'picture', 'see', 'glm-4.5v', '-v'];
                visionModels = models.filter(model =>
                    visionKeywords.some(keyword =>
                        model.id.toLowerCase().includes(keyword)
                    )
                );
            }

            logger.info(`Provider ${provider} 模型列表获取成功: 总计${models.length}个模型，其中${visionModels.length}个支持视觉`);

            // 获取所有可用模型（包含静态回退模型）
            const allAvailableModels = getAvailableModels(provider);

            // 重新过滤视觉模型，使用改进的filterVisionModels函数
            const allVisionModels = filterVisionModels(allAvailableModels);

            // 将API返回的模型ID转换为对象格式
            const apiModelIds = models.map(model => model.id);

            // 合并静态模型到模型列表
            const staticModels = allAvailableModels.filter(modelId => !apiModelIds.includes(modelId));
            const staticModelObjects = staticModels.map(modelId => ({
                id: modelId,
                object: 'model',
                created: Math.floor(Date.now() / 1000),
                owned_by: 'static-fallback'
            }));

            // 合并所有模型
            const allModels = [...models, ...staticModelObjects];

            // 创建完整的视觉模型对象列表
            const allVisionModelObjects = allModels.filter(model =>
                allVisionModels.includes(model.id)
            );

            // 将新发现的视觉模型与现有配置进行去重并追加到.env文件
            const newVisionModels = visionModels
                .map(model => model.id)
                .filter(modelId => !apiModelIds.includes(modelId));

            if (newVisionModels.length > 0) {
                try {
                    await addNewModelsToEnv(provider, newVisionModels);
                    console.log(`为Provider ${provider} 新增了 ${newVisionModels.length} 个视觉模型: ${newVisionModels.join(', ')}`);
                } catch (error) {
                    console.warn(`更新Provider ${provider} 模型配置失败:`, error.message);
                }
            }

            // 如果添加了静态模型，输出提示信息
            if (staticModels.length > 0) {
                console.log(`为${provider}添加静态回退模型: [${staticModels.join(', ')}]`);
            }

            return {
                success: true,
                provider: provider,
                baseUrl: config.base.replace(/\/[^\/]*$/, '/***'),
                total_models: allModels.length,
                vision_models: allVisionModelObjects.length,
                models: allModels,
                vision_models_list: allVisionModelObjects,
                new_models_found: newVisionModels.length,
                new_models_added: newVisionModels,
                static_models_added: staticModels
            };

        } catch (error) {
            clearTimeout(timeoutId);

            if (error.name === 'AbortError') {
                throw new Error(`获取模型列表超时 [Provider: ${provider}] (30秒)：请求超时，请检查网络连接或稍后重试`);
            } else {
                throw error;
            }
        }
    } catch (error) {
        console.error(`获取Provider ${provider} 模型列表失败:`, error.message);

        // 即使API调用失败，也尝试返回静态回退模型
        try {
            console.log(`API调用失败，尝试使用静态回退模型为Provider ${provider}...`);

            // 获取静态回退模型
            const staticModels = getAvailableModels(provider);
            const staticVisionModels = filterVisionModels(staticModels);

            // 转换为对象格式
            const staticModelObjects = staticModels.map(modelId => ({
                id: modelId,
                object: 'model',
                created: Math.floor(Date.now() / 1000),
                owned_by: 'static-fallback'
            }));

            const staticVisionModelObjects = staticModelObjects.filter(model =>
                staticVisionModels.includes(model.id)
            );

            if (staticModels.length > 0) {
                console.log(`为${provider}提供静态回退模型: [${staticModels.join(', ')}]`);
                console.log(`其中视觉模型: [${staticVisionModels.join(', ')}]`);

                return {
                    success: true,
                    provider: provider,
                    baseUrl: 'static-fallback',
                    total_models: staticModels.length,
                    vision_models: staticVisionModelObjects.length,
                    models: staticModelObjects,
                    vision_models_list: staticVisionModelObjects,
                    new_models_found: 0,
                    new_models_added: [],
                    static_models_added: staticModels,
                    note: 'API调用失败，使用静态回退模型'
                };
            } else {
                throw new Error(`Provider ${provider} 无可用配置且无静态回退模型`);
            }
        } catch (fallbackError) {
            return {
                success: false,
                provider: provider,
                error: error.message,
                fallback_error: fallbackError.message,
                message: `获取Provider ${provider}模型列表失败: ${error.message}`
            };
        }
    }
}

/**
 * 提取设计令牌 - 基于Design Tokens方法论的系统化设计分析
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 结构化的Design Tokens JSON数据
 */
async function extract_design_tokens(imgString) {
    const prompt = promptManager.getPrompt('extract_design_tokens');
    if (!prompt) {
        throw new Error('未配置extract_design_tokens提示词');
    }
    return await analyze_image(imgString, prompt);
}

/**
 * 生成设计系统JSON Schema - 为Design Tokens提供结构化约束
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 完整的设计系统JSON Schema
 */
async function generate_design_system_schema(imgString) {
    const prompt = promptManager.getPrompt('generate_design_system_schema');
    if (!prompt) {
        throw new Error('未配置generate_design_system_schema提示词');
    }
    return await analyze_image(imgString, prompt);
}

/**
 * 基于设计令牌生成代码 - 技术中立的代码生成
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @param {Object} options - 代码生成选项
 * @param {string} options.targetPlatform - 目标平台 (react, vue, flutter, html等)
 * @param {string} options.framework - 框架类型 (tailwind, bootstrap, material等)
 * @returns {Promise<string>} - 生成的代码文件和说明
 */
async function generate_code_from_design(imgString, options = {}) {
    const { targetPlatform = 'react', framework = 'tailwind' } = options;

    // 构建动态提示语
    const basePrompt = promptManager.getPrompt('generate_code_from_design');
    if (!basePrompt) {
        throw new Error('未配置generate_code_from_design提示词');
    }

    const enhancedPrompt = `${basePrompt}

Target Platform: ${targetPlatform}
CSS Framework: ${framework}

Please generate code specifically for this platform and framework combination.`;

    return await analyze_image(imgString, enhancedPrompt);
}

/**
 * 根据原型图生成HTML页面初始版本
 * @param {string} imgString - 图片的base64编码字符串或文件路径
 * @returns {Promise<string>} - 生成的HTML代码
 */
async function generate_html_from_prototype(imgString) {
    try {
        // 从配置文件获取prompt
        const prompt = promptManager.getPrompt('generate_html_from_prototype');
        if (!prompt) {
            throw new Error('未找到generate_html_from_prototype提示词配置');
        }

        return await analyze_image(imgString, prompt);
    } catch (error) {
        throw new Error(`HTML生成失败: ${error.message}`);
    }
}

module.exports = {
    analyze_image,
    compare_image,
    compare_image_with_bounding_boxes,
    use_model,
    list_models,
    delete_model,
    delete_model_for_provider,
    set_provider,
    add_provider,
    add_model_for_provider,
    addNewModelsToEnv,
    list_provider_models,
    analyze_design_screenshot,
    extract_component_hierarchy,
    get_exact_layout_specifications,
    identify_visual_tokens,
    analyze_design_with_precision,
    validateCurrentProviderModel,
    getCurrentProvider,
    getCurrentModel,
    getAvailableModels,
    getAvailableProviders,
    filterVisionModels,
    updateProvidersList,
    mergeVisionModels,
    updateProviderModels,
    isAutoMode,
    moveModelToEnd,
    moveProviderToEnd,
    callLLMApiWithRetry,
    extract_design_tokens,
    generate_design_system_schema,
    generate_code_from_design,
    generate_html_from_prototype
};